package com.utils;

import info.monitorenter.cpdetector.io.ASCIIDetector;
import info.monitorenter.cpdetector.io.CodepageDetectorProxy;
import info.monitorenter.cpdetector.io.JChardetFacade;
import info.monitorenter.cpdetector.io.ParsingDetector;
import info.monitorenter.cpdetector.io.UnicodeDetector;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.Charset;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.lang.ArrayUtils;
import org.apache.log4j.Logger;

public class FileUtil {
	private static Logger logger = Logger.getLogger(FileUtil.class);

	/**
	 * @Title: getBytesFromFile
	 * @Description: TODO(文件转化为字节数组)
	 * @param @param
	 *            file
	 * @param @return
	 * @param @throws
	 *            Exception 设定文件
	 * @return byte[] 返回类型
	 */
	@SuppressWarnings("resource")
	public static byte[] getBytesFromFile(File file) throws Exception {
		byte[] ret = null;
		if (file == null) {
			return null;
		}
		FileInputStream in = new FileInputStream(file);
		if (file.length() > Integer.MAX_VALUE) {
			// 文件太大，无法读取
			throw new IOException("File is to large " + file.getName());
		}
		ByteArrayOutputStream out = new ByteArrayOutputStream((int) file.length());
		byte[] b = new byte[4096];
		int n;
		while ((n = in.read(b)) != -1) {
			out.write(b, 0, n);
		}
		in.close();
		out.close();
		ret = out.toByteArray();
		return ret;
	}

	/**
	 * 拼装输入完整的sql
	 * @param sql
	 * @param params
	 * @return
	 */
	public static String getPreparedSQL(String sql, Object[] params) {
        //1 如果没有参数，说明是不是动态SQL语句
        int paramNum = 0;
        if (null != params)  paramNum = params.length;
        if (1 > paramNum) return sql;
        //2 如果有参数，则是动态SQL语句
        StringBuffer returnSQL = new StringBuffer();
        String[] subSQL = sql.split("\\?");
        for (int i = 0; i < paramNum; i++) {
            returnSQL.append(subSQL[i]).append(" '").append(params[i]).append("' ");
        }

        if (subSQL.length > params.length) {
            returnSQL.append(subSQL[subSQL.length - 1]);
        }
        return returnSQL.toString();
    }
	 
	/**
	 * 生成sql文件
	 */
	public static void createFileBySql(String filePath,String fileSuff,String sql,List<Object[]> sqlParam){
		BufferedWriter bw = null;
		String timeStr = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
		File sqlFile = new File(filePath+File.separator+fileSuff+"-"+timeStr+".sql~");
		try {
			if(sqlParam!=null && sqlParam.size() > 0){
				if(!sqlFile.getParentFile().exists()){
					createFolder(sqlFile.getParentFile().getAbsolutePath());
				}
				if(!sqlFile.exists()){
					sqlFile.createNewFile();
				}
				bw = new BufferedWriter(new FileWriter(sqlFile));
				for (Object[] param : sqlParam) {
					bw.append(getPreparedSQL(sql, param));
					bw.newLine();
					bw.flush();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){ 
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(sqlFile.length()>0){
				sqlFile.renameTo(
						new File(filePath + File.separator + fileSuff + "-" + timeStr + ".sql"));
			}
		}
	}
	
	/**
	 * 生成sql文件
	 * @param filePath
	 * @param fileSuff
	 * @param deteleSql
	 * @param sql
	 * @param sqlParam
	 */
	public static void createFileBySql(String filePath,String fileSuff,String deteleSql,String sql,List<Object[]> sqlParam){
		BufferedWriter bw = null;
		String timeStr = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
		File sqlFile = new File(filePath+File.separator+fileSuff+"-"+timeStr+".sql~");
		try {
			if(sqlParam!=null && sqlParam.size() > 0){
				if(!sqlFile.getParentFile().exists()){
					createFolder(sqlFile.getParentFile().getAbsolutePath());
				}
				if(!sqlFile.exists()){
					sqlFile.createNewFile();
				}
				bw = new BufferedWriter(new FileWriter(sqlFile));
				if(deteleSql!=null&&"".equals(deteleSql)){
					bw.append(deteleSql);
					bw.newLine();
					bw.flush();
				}
				for (Object[] param : sqlParam) {
					bw.append(getPreparedSQL(sql, param));
					bw.newLine();
					bw.flush();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){ 
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(sqlFile.length()>0){
				sqlFile.renameTo(
						new File(filePath + File.separator + fileSuff + "-" + timeStr + ".sql"));
			}
		}
	}
	
	/**
	 * 生成sql文件
	 * @param filePath
	 * @param fileSuff
	 * @param sql
	 */
	public static void createFileBySql(String filePath,String fileSuff,List<String> sqls){
		BufferedWriter bw = null;
		String timeStr = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
		File sqlFile = new File(filePath+File.separator+fileSuff+"-"+timeStr+".sql~");
		try {
			if(sqls!=null && sqls.size() > 0){
				if(!sqlFile.getParentFile().exists()){
					createFolder(sqlFile.getParentFile().getAbsolutePath());
				}
				if(!sqlFile.exists()){
					sqlFile.createNewFile();
				}
				bw = new BufferedWriter(new FileWriter(sqlFile));
				for (String sql : sqls) {
					bw.append(sql);
					bw.newLine();
					bw.flush();
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){ 
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(sqlFile.length()>0){
				sqlFile.renameTo(
						new File(filePath + File.separator + fileSuff + "-" + timeStr + ".sql"));
			}
		}
	}
	
	
	/**
	 * @Title: getFileFromBytes
	 * @Description: TODO(把字节数组保存为一个文件)
	 * @param b
	 *            字符数组
	 * @param outputFile
	 *            输出文件路径
	 * @return File 返回类型
	 */
	public static File getFileFromBytes(byte[] b, String outputFile) {
		File ret = null;
		BufferedOutputStream stream = null;
		try {
			ret = new File(outputFile);
			FileOutputStream fstream = new FileOutputStream(ret);
			stream = new BufferedOutputStream(fstream);
			stream.write(b);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (stream != null) {
				try {
					stream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return ret;
	}

	/**
	 * @Title: zipFiles
	 * @Description: TODO(压缩文件夹)
	 * @param files
	 *            文件列表
	 * @param targetZipFile
	 *            生成zip文件名
	 * @return void 返回类型
	 */
	public static void zipFiles(List<File> files, String targetZipFile) {
		try {
			FileOutputStream target = new FileOutputStream(targetZipFile);
			ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(target));
			int BUFFER_SIZE = 1024;
			byte buff[] = new byte[BUFFER_SIZE];
			for (int i = 0; i < files.size(); i++) {
				FileInputStream fi = new FileInputStream(files.get(i));
				BufferedInputStream origin = new BufferedInputStream(fi);
				ZipEntry entry = new ZipEntry(files.get(i).getName());
				out.putNextEntry(entry);
				int count;
				while ((count = origin.read(buff)) != -1) {
					out.write(buff, 0, count);
				}
				origin.close();
			}
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判断文件是否存在
	 */
	public static boolean fileExists(String path, String fileName) {
		// 判断c:/test/ 是否是/结尾
		if (!path.endsWith(File.separator)) {
			path = path + File.separator;
		}
		File file = new File(path + fileName);
		return file.exists();
	}

	/**
	 * @Title: readFile
	 * @Description: TODO(读取指定文件内容 path:文件名（目录加文件名） 返回字符串)
	 * @param path
	 * @return String 返回类型
	 */
	public static String readFile(String path) {
		File filename = new File(path);
		String read;
		FileReader fileread;
		BufferedReader bufread = null;
		String readStr = "";
		try {
			fileread = new FileReader(filename);
			bufread = new BufferedReader(fileread);
			try {
				while ((read = bufread.readLine()) != null) {// 判断是否为空
					readStr = readStr + read + "\r\n";
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			logger.info("未找到文件" + filename);
		} finally {
			try {
				bufread.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return readStr;
	}

	/**
	 * @Title: readFileTolist
	 * @Description: TODO(读取指定文件内容 path:文件名（目录加文件名） 返回集合)
	 * @param path
	 * @return List<String> 返回类型
	 */
	public static List<String> readFileTolist(String path) {
		File filename = new File(path);
		String read;
		FileReader fileread;
		BufferedReader bufread = null;
		List<String> list = new ArrayList<String>();
		try {
			fileread = new FileReader(filename);
			bufread = new BufferedReader(fileread);
			try {
				while ((read = bufread.readLine()) != null) {// 判断是否为空
					list.add(read);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			logger.info("未找到文件" + filename);
		} finally {
			try {
				bufread.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return list;
	}

	/**
	 * @Title: readFileTolist
	 * @Description: TODO(读取指定文件内容)
	 * @param filename
	 *            文件
	 * @return List<String> 返回类型
	 */
	public static List<String> readFileTolist(File filename) {
		String read;
		FileReader fileread;
		BufferedReader bufread = null;
		List<String> list = new ArrayList<String>();
		try {
			fileread = new FileReader(filename);
			bufread = new BufferedReader(fileread);
			try {
				while ((read = bufread.readLine()) != null) {// 判断是否为空
					list.add(read);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				fileread.close();
				bufread.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			logger.info("未找到文件" + filename);
		}
		return list;
	}

	/**
	 * @Title: writeFile
	 * @Description: TODO(追加内容到文件末尾)
	 * @param path
	 *            指定文件路径
	 * @param newStr
	 *            要追加的内容
	 * @return void
	 */
	public static void writeFile(String path, String newStr) {
		FileOutputStream fileoutput = null;
		OutputStreamWriter output = null;
		BufferedWriter out = null;
		try {
			fileoutput = new FileOutputStream(path, true);
			output = new OutputStreamWriter(fileoutput);
			out = new BufferedWriter(output);
			if (System.getProperty("os.name").equals("Linux")) {// 判断系统是Linux还是windows
				out.write("\n" + newStr);
			} else {
				out.write("\r\n" + newStr);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				out.close();
				output.close();
				fileoutput.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * @Title: getFileList
	 * @Description: TODO(获取指定文件夹下的所有文件(不包括子文件夹中的文件))
	 * @param path
	 * @return List<File> 返回类型
	 */
	public static List<File> getFileList(String path) {
		List<File> fileInfo = new ArrayList<File>();
		File root = new File(path);
		File[] files = root.listFiles(new FileFilter() {
			public boolean accept(File pathname) {
				if (pathname.isDirectory() && pathname.isHidden()) { // 去掉隐藏文件夹
					return false;
				}
				if (pathname.isFile() && pathname.isHidden()) {// 去掉隐藏文件
					return false;
				}
				return true;
			}
		});
		// 逐个遍历文件
		for (File file : files) {
			// 判断是否是文件夹
			if (!file.isDirectory()) {
				// 如果不是文件夹，则添加入文件列表
				fileInfo.add(file);
			}
		}
		return fileInfo;
	}

	/**
	 * @Title: getFileList2
	 * @Description: TODO(获取指定文件夹下的所有文件和文件夹)
	 * @param path
	 * @return List<File> 返回类型
	 */
	public static List<File> getFileList2(String path) {
		List<File> fileInfo = new ArrayList<File>();
		File root = new File(path);
		File[] files = root.listFiles(new FileFilter() {
			public boolean accept(File pathname) {
				// 去掉隐藏文件夹
				if (pathname.isDirectory() && pathname.isHidden()) {
					return false;
				}
				// 去掉隐藏文件
				if (pathname.isFile() && pathname.isHidden()) {
					return false;
				}
				return true;
			}
		});
		// 逐个遍历文件
		for (File file : files) {
			// 添加入文件列表
			fileInfo.add(file);
		}
		return fileInfo;
	}

	/**
	 * @Title: getFileAllList
	 * @Description: TODO(获取指定文件夹下的所有文件(包括子文件夹中的文件))
	 * @param @param
	 *            path
	 * @param @return
	 *            设定文件
	 * @return List<File> 返回类型
	 */
	public static List<File> getFileAllList(String path) {
		List<File> fileInfo = new ArrayList<File>();
		File root = new File(path);
		File[] files = root.listFiles(new FileFilter() {
			public boolean accept(File pathname) {
				if (pathname.isDirectory() && pathname.isHidden()) { // 去掉隐藏文件夹
					return false;
				}
				if (pathname.isFile() && pathname.isHidden()) {// 去掉隐藏文件
					return false;
				}
				return true;
			}
		});
		// 逐个遍历文件
		for (File file : files) {
			// 如果是文件夹，则进一步遍历，属于递归算法
			if (file.isDirectory()) {
				List<File> ff = getFileAllList(file.getPath());
				fileInfo.addAll(ff);
			} else {
				// 如果不是文件夹，则添加入文件列表
				fileInfo.add(file);
			}
		}
		return fileInfo;
	}

	/**
	 * @Title: getFileAllList
	 * @Description: TODO(获取指定文件夹下的所有文件(包括子文件夹中的文件))
	 * @param path
	 * @param fileFilter
	 * @return List<File> 返回类型
	 */
	public static List<File> getFileAllList(String path, FileFilter fileFilter) {
		List<File> fileInfo = new ArrayList<File>();
		File root = new File(path);
		File[] files = root.listFiles(fileFilter);
		for (File file : files) {// 逐个遍历文件
			if (file.isDirectory()) { // 如果是文件夹，则进一步遍历，属于递归算法
				List<File> ff = getFileAllList(file.getPath());
				fileInfo.addAll(ff);
			} else {
				fileInfo.add(file); // 如果不是文件夹，则添加入文件列表
			}
		}
		List<File> reMoveList = new ArrayList<File>();
		if (fileInfo != null)
			for (File f : fileInfo) {
				boolean isAccept = fileFilter.accept(f);
				if (!isAccept)
					reMoveList.add(f);
			}
		if (reMoveList.size() > 0)
			fileInfo.removeAll(reMoveList);
		return fileInfo;
	}

	/**
	 * @Title: newFolder
	 * @Description: TODO(新建目录)
	 * @param folderPath
	 * @return void 返回类型
	 */
	public static void newFolder(String folderPath) {
		try {
			String filePath = folderPath;
			filePath = filePath.toString();
			File myFilePath = new File(filePath);
			if (!myFilePath.exists()) {
				myFilePath.mkdirs();
			}
		} catch (Error e) {
			System.out.println("新建目录操作出错 ");
			e.printStackTrace();
		}
	}

	/**
	 * @Title: newFile
	 * @Description: TODO(新建文件)
	 * @param filePathAndName
	 *            文件路径及名称 如c:/fqf.txt
	 * @param fileContent
	 *            文件内容
	 * @return void 返回类型
	 */
	public static void newFile(String filePathAndName, String fileContent) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myFilePath = new File(filePath);
			if (!myFilePath.exists()) {
				myFilePath.createNewFile();
			}
			FileWriter resultFile = new FileWriter(myFilePath);
			PrintWriter myFile = new PrintWriter(resultFile);
			String strContent = fileContent;
			myFile.println(strContent);
			resultFile.close();
			myFile.close();
		} catch (Exception e) {
			// System.out.println("新建文件操作出错 ");
			e.printStackTrace();
		}

	}

	/**
	 * @Title: delFile
	 * @Description: TODO(删除文件)
	 * @param filePathAndName
	 *            文件路径及名称 如c:/fqf.txt
	 * @return void 返回类型
	 */
	public static void delFile(String filePathAndName) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			File myDelFile = new File(filePath);
			myDelFile.delete();
		} catch (Exception e) {
			logger.info("删除文件操作出错 ");
			e.printStackTrace();
		}

	}

	/**
	 * @Title: delFolder
	 * @Description: TODO(删除文件夹)
	 * @param folderPath
	 *            文件路径
	 * @return void 返回类型
	 */
	public static void delFolder(String folderPath) {
		try {
			delAllFile(folderPath); // 删除完里面所有内容
			String filePath = folderPath;
			filePath = filePath.toString();
			File myFilePath = new File(filePath);
			// 删除空文件夹
			myFilePath.delete();
		} catch (Exception e) {
			logger.info("删除文件夹操作出错 ");
			e.printStackTrace();

		}

	}

	/**
	 * @Title: deleteFile @Description: 批量删除指定文件 @param filePath 文件路径 @return
	 * void 返回类型 @throws
	 */
	static public void deleteFile(String[] filePath) {
		if (filePath != null) {
			for (String fp : filePath) {
				delFile(fp);
			}
		}
	}

	/**
	 * @Title: deleteFile
	 * @Description: 批量删除指定文件
	 * @param files
	 *            文件列表
	 * @return void 返回类型
	 */
	static public void deleteFile(List<File> files) {
		if (files != null) {
			for (File f : files) {
				f.delete();
			}
		}
	}

	/**
	 * @Title: delAllFile
	 * @Description: TODO(删除文件夹里面的所有文件)
	 * @param path
	 *            文件夹路径 如 c:/fqf
	 * @return void 返回类型
	 */
	public static void delAllFile(String path) {
		if (path == null) {
			return;
		}
		File file = new File(path);
		if (!file.exists()) {
			return;
		}
		if (!file.isDirectory()) {
			return;
		}
		String[] tempList = file.list();
		File temp = null;
		for (int i = 0; i < tempList.length; i++) {
			if (path.endsWith(File.separator)) {
				temp = new File(path + tempList[i]);
			} else {
				temp = new File(path + File.separator + tempList[i]);
			}
			if (temp.isFile()) {
				temp.delete();
			}
			if (temp.isDirectory()) {
				delAllFile(path + File.separator + tempList[i]);// 先删除文件夹里面的文件
				delFolder(path + File.separator + tempList[i]);// 再删除空文件夹
			}
		}
	}

	/**
	 * @Title: copyFile
	 * @Description: TODO(复制单个文件)
	 * @param oldPath
	 *            原文件路径 如：c:/fqf.txt
	 * @param newPath
	 *            复制后路径 如：f:/fqf.txt
	 * @return void 返回类型
	 */
	public static void copyFile(String oldPath, String newPath) {
		InputStream inStream = null;
		try {
			int byteread = 0;
			File oldfile = new File(oldPath);
			if (oldfile.exists()) { // 文件存在时
				inStream = new FileInputStream(oldPath); // 读入原文件
				FileOutputStream fs = new FileOutputStream(newPath);
				byte[] buffer = new byte[1444];
				while ((byteread = inStream.read(buffer)) != -1) {
					fs.write(buffer, 0, byteread);
				}
				fs.flush();
				fs.close();
				inStream.close();
			}
		} catch (Exception e) {
			logger.info("复制单个文件操作出错 ");
			e.printStackTrace();
		} finally {
			if (inStream != null) {
				try {
					inStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

	/**
	 * @Title: copyFolder
	 * @Description: TODO(复制整个文件夹内容)
	 * @param oldPath
	 *            原文件路径 如：c:/fqf
	 * @param newPath
	 *            复制后路径 如：f:/fqf/ff
	 * @return void 返回类型
	 */
	public static void copyFolder(String oldPath, String newPath) {
		try {
			(new File(newPath)).mkdirs(); // 如果文件夹不存在 则建立新文件夹
			File a = new File(oldPath);
			String[] file = a.list();
			File temp = null;
			for (int i = 0; i < file.length; i++) {
				if (oldPath.endsWith(File.separator)) {
					temp = new File(oldPath + file[i]);
				} else {
					temp = new File(oldPath + File.separator + file[i]);
				}
				if (temp.isFile()) {
					FileInputStream input = new FileInputStream(temp);
					FileOutputStream output = new FileOutputStream(
							newPath + File.separator + (temp.getName()).toString());
					byte[] b = new byte[1024 * 5];
					int len;
					while ((len = input.read(b)) != -1) {
						output.write(b, 0, len);
					}
					output.flush();
					output.close();
					input.close();
				}
				if (temp.isDirectory()) {// 如果是子文件夹
					copyFolder(oldPath + File.separator + file[i], newPath + File.separator + file[i]);
				}
			}
		} catch (Exception e) {
			logger.info("复制整个文件夹内容操作出错 ");
			e.printStackTrace();

		}

	}

	/**
	 * @Title: moveFile
	 * @Description: TODO(移动文件到指定目录)
	 * @param oldPath
	 *            如：c:/fqf.txt
	 * @param newPath
	 *            如：d:/fqf.txt
	 * @return void 返回类型
	 */
	public static void moveFile(String oldPath, String newPath) {
		copyFile(oldPath, newPath);
		delFile(oldPath);
	}

	/**
	 * @Title: moveFolder
	 * @Description: TODO(移动文件夹到指定目录)
	 * @param oldPath
	 *            如：c:/fqf
	 * @param newPath
	 *            如：d:/fqf
	 * @return void 返回类型
	 */
	public static void moveFolder(String oldPath, String newPath) {
		copyFolder(oldPath, newPath);
		delFolder(oldPath);
	}

	/**
	 * 
	 * @Title: chekPath
	 * @Description: TODO(判断路径是否以斜杠结尾，如果不是则添加，是则直接返回)
	 * @param path
	 * @return String 返回类型
	 */
	public static String chekPath(String path) {
		if (!path.endsWith(File.separatorChar + "")) {
			path += File.separatorChar + "";
		}
		return path;
	}

	/**
	 * @Title: catPath
	 * @Description: 将两个路径拼接在一起
	 * @param rootPath
	 * @param subPath
	 * @return String 返回类型
	 */
	public static String catPath(String rootPath, String subPath) {
		if (rootPath != null && subPath != null) {
			if (subPath.startsWith(File.separatorChar + ""))
				subPath = subPath.substring(0, subPath.length());
			return chekPath(rootPath) + subPath;
		}
		return "";
	}

	/**
	 * @Title: dirExists
	 * @Description: TODO(文件夹是否存在)
	 * @param dir
	 *            文件夹路径
	 * @return boolean 返回类型
	 */
	public static boolean dirExists(String dir) {
		boolean flag = false;
		File file = new File(dir);
		if (!file.exists()) {
			flag = file.mkdirs();
		}
		return flag;
	}

	/**
	 * @Title: makeDir
	 * @Description: 创建文件夹目录 add by 胡俊岩
	 * @param path
	 * @param forFile
	 *            true 时，dir 是一文件名
	 * @return boolean 返回类型
	 */
	static public final boolean makeDir(String path, boolean forFile) {
		return makeDir(new File(path), forFile);
	}

	/**
	 * @Title: makeDir
	 * @Description: 创建文件夹目录 add by 胡俊岩
	 * @param f
	 * @param forFile
	 * @return boolean 返回类型
	 */
	static public final boolean makeDir(File f, boolean forFile) {
		if (!forFile) {
			if (f.exists()) {
				return f.isDirectory();
			}
			return f.mkdirs();
		}
		return makeDir(f.getParentFile(), false);
	}

	/**
	 * @Title: Sort
	 * @Description: TODO(对数组进行循环移位比较，冒泡排序)
	 * @param arr
	 * @return String 最大的字符串
	 */
	public static String Sort(String[] arr) {
		String s1, s2;
		int flag, y;

		for (int x = 0; x < arr.length; x++) {
			// 得出需要比较大小排序的字符串数量
			y = arr.length;
			for (int i = 0; i < y - 1; i++) {
				s1 = arr[i];
				s2 = arr[i + 1];
				// 比较字符串大小
				flag = s1.compareToIgnoreCase(s2);
				if (flag >= 0) {
					arr[i] = s2;
					arr[i + 1] = s1;
				}
			}
			y = y - 1;
		}
		return arr[(arr.length - 1)];
	}

	/**
	 * @Title: getFileExtensionFilterByExpStr
	 * @Description: TODO(返回指定扩展名的文件列表，以;隔开，如.jpg;.gif)
	 * @param exp
	 *            以;隔开的文件扩展名字符串 如.jpg;.gif
	 * @return FilenameFilter 返回类型
	 */
	public static FilenameFilter getFileExtensionFilterByExpStr(String exp) {
		final String[] expArr = exp.split(";");
		return new FilenameFilter() {
			public boolean accept(File file, String name) {
				boolean flag = false;
				for (int i = 0; i < expArr.length; i++) {
					if (name.endsWith(expArr[i]))
						flag = true;
				}
				return flag;
			}
		};
	}

	/**
	 * @Title: separatorReplace
	 * @Description: TODO(分隔符替换 window下测试通过)
	 * @param path
	 * @return String
	 */
	public static String separatorReplace(String path) {
		return path.replace("\\", "/");
	}

	/** 
	* @Title: createFolder 
	* @Description: TODO(创建文件夹，如果文件夹存在则不进行创建) 
	* @param path 
	* @return void
	*/
	public static void createFolder(String path) {
		path = separatorReplace(path);
		File folder = new File(path);
		if (folder.isDirectory()) {
			return;
		}
		folder.mkdirs();
	}

	/** 
	* @Title: delete 
	* @Description: TODO(删除文件) 
	* @param fileName
	* @return boolean
	*/
	public static boolean delete(String fileName) {
		File file = new File(fileName);
		if (!file.exists()) {
			logger.info("删除文件失败:" + fileName + "不存在！");
			return false;
		} else {
			if (file.isFile()) {
				return deleteFile1(fileName);
			} else {
				return false;
			}
		}
	}

	public static boolean deleteFile1(String fileName) {
		File file = new File(fileName);
		// 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
		if (file.exists() && file.isFile()) {
			System.gc();
			if (file.delete()) {
				System.out.println("删除单个文件" + fileName + "成功！");
				return true;
			} else {
				System.out.println("删除单个文件" + fileName + "失败！");
				return false;
			}
		} else {
			System.out.println("删除单个文件失败：" + fileName + "不存在！");
			return false;
		}
	}

	/** 
	* @Title: getFileEncode 
	* @Description: TODO(利用第三方开源包cpdetector获取文件编码格式) 
	* @param path 要判断文件编码格式的源文件的路径
	* @param defaultCode 默认编码格式
	* @return String
	*/
	public static String getFileEncode(String path,String defaultCode) {
		/*
		 * detector是探测器，它把探测任务交给具体的探测实现类的实例完成。
		 * cpDetector内置了一些常用的探测实现类，这些探测实现类的实例可以通过add方法 加进来，如ParsingDetector、
		 * JChardetFacade、ASCIIDetector、UnicodeDetector。
		 * detector按照“谁最先返回非空的探测结果，就以该结果为准”的原则返回探测到的
		 * 字符集编码。使用需要用到三个第三方JAR包：antlr.jar、chardet.jar和cpdetector.jar
		 * cpDetector是基于统计学原理的，不保证完全正确。
		 */
		CodepageDetectorProxy detector = CodepageDetectorProxy.getInstance();
		/*
		 * ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
		 * 指示是否显示探测过程的详细信息，为false不显示。
		 */
		detector.add(new ParsingDetector(false));
		/*
		 * JChardetFacade封装了由Mozilla组织提供的JChardet，它可以完成大多数文件的编码
		 * 测定。所以，一般有了这个探测器就可满足大多数项目的要求，如果你还不放心，可以
		 * 再多加几个探测器，比如下面的ASCIIDetector、UnicodeDetector等。
		 */
		detector.add(JChardetFacade.getInstance());// 用到antlr.jar、chardet.jar
		// ASCIIDetector用于ASCII编码测定
		detector.add(ASCIIDetector.getInstance());
		// UnicodeDetector用于Unicode家族编码的测定
		detector.add(UnicodeDetector.getInstance());
		Charset charset = null;
		File f = new File(path);
		try {
			charset = detector.detectCodepage(f.toURI().toURL());
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		if (charset != null)
			return charset.name();
		else
			return defaultCode;
	}

	/**
	 * @Title: MergeFiles 
	 * @Description: TODO(合并文件)
	 * @param filePath
 	 * @param fileName 
 	 * @param mergeFilePath
	 */
	public static void MergeFiles(String filePath, List<String> fileName, String mergeFilePath) {
		BufferedReader br = null;
		OutputStreamWriter osw = null;
		File fi = new File(mergeFilePath);
		if (fi.isDirectory() || !fi.exists()) {
			try {
				fi.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			FileWriter fw = new FileWriter(fi);
			fw.write("");
			fw.close();
			osw = new OutputStreamWriter(new FileOutputStream(fi, true), "UTF-8");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		for (String file : fileName) {
			String code = "";
			try {
				code = getFileEncode(filePath + File.separator + file,"UTF-8");
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
			try {
				String line = "";
				// br = new BufferedReader(new
				// FileReader(filePath+File.separator+file));
				br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath + File.separator + file),
						Charset.forName(code)));
				while ((line = br.readLine()) != null) {
					// System.out.println(line);
					osw.write(line + "\n");
				}
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		try {
			if (osw != null) {
				osw.close();
			}
			if (br != null) {
				br.close();
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * @Title: copyFile 
	 * @Description: TODO(复制文件)
	 * @param srcFileName 源文件
	 * @param destFileName 目标文件 
	 * @param overlay 是否覆盖
	 * @return boolean 
	 */
	public static boolean copyFile(String srcFileName, String destFileName, boolean overlay) {
		File srcFile = new File(srcFileName);
		// 判断源文件是否存在
		if (!srcFile.exists()) {
			logger.info("源文件：" + srcFileName + "不存在！");
			return false;
		} else if (!srcFile.isFile()) {
			logger.info("复制文件失败，源文件：" + srcFileName + "不是一个文件！");
			return false;
		}

		// 判断目标文件是否存在
		File destFile = new File(destFileName);
		if (destFile.exists()) {
			// 如果目标文件存在并允许覆盖
			if (overlay) {
				// 删除已经存在的目标文件，无论目标文件是目录还是单个文件
				new File(destFileName).delete();
			}
		} else {
			// 如果目标文件所在目录不存在，则创建目录
			if (!destFile.getParentFile().exists()) {
				// 目标文件所在目录不存在
				if (!destFile.getParentFile().mkdirs()) {
					// 复制文件失败：创建目标文件所在目录失败
					return false;
				}
			}
		}

		// 复制文件
		int byteread = 0; // 读取的字节数
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(srcFile);
			out = new FileOutputStream(destFile);
			byte[] buffer = new byte[1024];

			while ((byteread = in.read(buffer)) != -1) {
				out.write(buffer, 0, byteread);
			}
			return true;
		} catch (FileNotFoundException e) {
			return false;
		} catch (IOException e) {
			return false;
		} finally {
			try {
				if (out != null)
					out.close();
				if (in != null)
					in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * @Title: copyFiles 
	 * @Description: TODO(批量复制文件) 
	 * @param fileNames 文件名称
	 * @param srcPath 源文件路径 
	 * @param destDir 目标路径 
	 * @param overlay 是否覆盖
	 */
	public static boolean copyFiles(List<String> fileNames, String srcPath, String destDir, boolean overlay) {
		List<String> srcFiles = new ArrayList<String>();
		if (!srcPath.endsWith(File.separator)) {
			srcPath = srcPath + File.separator;
		}
		if (fileNames != null) {
			for (String fileName : fileNames) {
				srcFiles.add(srcPath + fileName);
			}
		}
		return copyFiles(srcFiles, destDir, overlay);
	}

	/**
	 * @Title: removeAllFiles 
	 * @Description: TODO(批量移动文件) 
	 * @param srcPath 源文件路径 
	 * @param destDir 目标路径 
	 * @param overlay 是否覆盖
	 */
	public static boolean removeAllFiles(String srcPath, String destDir, boolean overlay) {
		File f = new File(srcPath);
		if(f.exists()&&!f.isDirectory()){
			return false;
		}
		
		try{
			List<String> fileNames = new ArrayList<String>();
			File[] files = f.listFiles();
			for (File file : files) {
				
				fileNames.add(file.getName());
			}
			copyFiles(fileNames,srcPath,destDir,overlay);
			deleteFile(fileNames,srcPath);
		}catch(Exception e){
			e.printStackTrace();
			return false;
		}
		
		return true;
	}
	/**
	 * @Title: removeAllFiles 
	 * @Description: TODO(批量移动文件) 
	 * @param srcPath 源文件路径 
	 * @param destDir 目标路径 
	 * @param overlay 是否覆盖
	 */
	public static boolean removeAllFiles(String srcPath,List<String> fileNames, String destDir, boolean overlay) {
		File f = new File(srcPath);
		if(f.exists()&&!f.isDirectory()){
			return false;
		}
		try{
			if(fileNames!=null && fileNames.size()>0){
				copyFiles(fileNames,srcPath,destDir,overlay);
				deleteFile(fileNames,srcPath);
			}
		}catch(Exception e){
			e.printStackTrace();
			return false;
		}
		
		return true;
	}
	/**
	 * @Title: removeAllFiles 
	 * @Description: TODO(批量移动文件区分成功失败) 
	 * @param srcPath 源文件路径 
	 * @param destDir 目标路径 
	 * @param overlay 是否覆盖
	 */
	public static boolean removeAllFiles(String srcPath,Map<String,String> fileNames, String destDir, boolean overlay) {
		File f = new File(srcPath);
		if(f.exists()&&!f.isDirectory()){
			return false;
		}
		try{
			if(fileNames!=null && fileNames.size()>0){
					Set<String> keys = fileNames.keySet();
					Map<String,String> srcFiles = new HashMap<String,String>();
					if (!srcPath.endsWith(File.separator)) {
						srcPath = srcPath + File.separator;
					}
					for (String key : keys) {
						srcFiles.put((srcPath+key),fileNames.get(key));
					}
					copyFiles(srcFiles, destDir, overlay);
					deleteFile(fileNames,srcPath);
			}
		}catch(Exception e){
			e.printStackTrace();
			return false;
		}
		
		return true;
	}
	public static String getDefaultPath(){
		String path = "";
		String[] dateStr = DateUtils.getCurrentDay("yyyy-MM-dd").split("-");
		path = dateStr[0]+File.separator+dateStr[1]+File.separator+dateStr[2]+File.separator;
		return path;
	}
	/**
	 * @Title: copyFiles 
	 * @Description: TODO(批量复制文件) 
	 * @param srcFiles 源文件 绝对路径
	 * @param destDir 目标文件目录 
	 * @param overlay 是否覆盖 
	 */
	public static boolean copyFiles(List<String> srcFiles, String destDir, boolean overlay) {
		// 如果目标目录名不是以文件分隔符结尾，则加上文件分隔符
		if (!destDir.endsWith(File.separator)) {
			destDir = destDir + File.separator;
		}
		destDir+=getDefaultPath();
		File destDirFi = new File(destDir);
		// 如果目标文件夹存在
		if (destDirFi.exists()) {
			// 如果允许覆盖则删除已存在的目标目录
			if (overlay) {
				new File(destDir).delete();
			} 
		} else {
			// 创建目的目录
			logger.info("目的目录不存在，准备创建。。。");
			if (!destDirFi.mkdirs()) {
				logger.info("复制目录失败：创建目的目录失败！");
				return false;
			}
		}

		boolean flag = true;
		for (int i = 0; i < srcFiles.size(); i++) {
			File f = new File(srcFiles.get(i));
			// 复制文件
			if (f.exists() && f.isFile()) {
				flag = copyFile(srcFiles.get(i), destDir + f.getName(), overlay);
				if (!flag)
					break;
			}
		}
		if (!flag) {
			logger.info("复制文件到目录" + destDir + "失败！");
			return false;
		} else {
			return true;
		}
	}
	/**
	 * @Title: copyFiles 
	 * @Description: TODO(批量复制文件) 
	 * @param srcFiles 源文件 绝对路径
	 * @param destDir 目标文件目录 
	 * @param overlay 是否覆盖 
	 */
	public static boolean copyFiles(Map<String, String> srcFile,String destDir, boolean overlay) {
		// 如果目标目录名不是以文件分隔符结尾，则加上文件分隔符
		if (!destDir.endsWith(File.separator)) {
			destDir = destDir + File.separator;
		}
		destDir+=getDefaultPath();
		File destDirFiS = new File(destDir+ContanUtils.FILE_REMOVE_SUCCESS);
		File destDirFiE = new File(destDir+ContanUtils.FILE_REMOVE_ERROR);
		// 如果目标文件夹不存在
		if (!destDirFiS.exists()) {
			// 创建目的目录
			logger.info("目的目录不存在，准备创建。。。");
			if (!destDirFiS.mkdirs()) {
				logger.info("复制目录失败：创建目的目录失败！");
				return false;
			}
		}
		if (!destDirFiE.exists()) {
			// 创建目的目录
			logger.info("目的目录不存在，准备创建。。。");
			if (!destDirFiE.mkdirs()) {
				logger.info("复制目录失败：创建目的目录失败！");
				return false;
			}
		}
		boolean flag = true;
		Set<String> keys = srcFile.keySet();
		for (String key : keys) {
			File f = new File(key);
			// 复制文件
			if (f.exists() && f.isFile()) {
				flag = copyFile(key, destDir+srcFile.get(key)+File.separator+f.getName(), overlay);
				if (!flag)
					break;
			}
		}
		if (!flag) {
			logger.info("复制文件到目录" + destDir + "失败！");
			return false;
		} else {
			return true;
		}
	}

	/**
	 * @Title: deleteFile 
	 * @Description: TODO(删除文件) 
	 * @param  srcFiles 
	 * @return boolean
	 */
	public static void deleteFile(List<String> fileName, String path) {
		if (fileName != null) {
			if (!path.endsWith(File.separator)) {
				path += File.separator;
			}
			for (String str : fileName) {
				File f = new File(path + str);
				if (f.exists() && f.isFile()) {
					if (!f.delete()) {
						logger.info("文件" + path + str + "删除失败");
					}
				} else {
					logger.info("文件路径" + path + str + "跳过删除");
				}
			}
		}
	}
	/**
	 * @Title: deleteFile 
	 * @Description: TODO(删除文件) 
	 * @param  srcFiles 
	 * @return boolean
	 */
	public static void deleteFile(Map<String, String> fileName, String path) {
		if (fileName != null) {
			if (!path.endsWith(File.separator)) {
				path += File.separator;
			}
			Set<String> keys = fileName.keySet();
			for (String key : keys) {
				File f = new File(path + key);
				if (f.exists() && f.isFile()) {
					if (!f.delete()) {
						logger.info("文件" + path + key + "删除失败");
					}
				} else {
					logger.info("文件路径" + path + key + "跳过删除");
				}
			}
		}
	}

	
	/**
	 * 改变数组内容
	 * @param obj
	 * @param i
	 * @param j
	 * @return
	 */
	public static Object[] changeArray(Object[] obj,int i,int j){
		Object[] param = ArrayUtils.clone(obj);
		try {
			param[j] = ContanUtils.STR_SEP+param[i]+ContanUtils.STR_SEP;
		} catch (Exception e) {
			// TODO: handle exception
			return obj;
		}
		return param;
	}
	
	/**
	 * 给定根目录，返回一个相对路径所对应的实际文件对象
	 * 
	 * @param zippath
	 *            指定根目录
	 * @param absFileName
	 *            相对路径名，来自于ZipEntry中的name
	 * @return File 实际的文件
	 */
	private static File getRealFileName(String zippath, String absFileName) {
		String[] dirs = absFileName.split("/", absFileName.length());
		File ret = new File(zippath);// 创建文件对象
		if (dirs.length > 1) {
			for (int i = 0; i < dirs.length - 1; i++) {
				ret = new File(ret, dirs[i]);
			}
		}
		if (!ret.exists()) {
			// 检测文件是否存在
			ret.mkdirs();// 创建此抽象路径名指定的目录
		}
		// 根据 ret 抽象路径名和 child 路径名字符串创建一个新 File 实例
		ret = new File(ret, dirs[dirs.length - 1]);
		return ret;
	}
}